package cn.bdqn.mh.service.impl;

import cn.bdqn.mh.mapper.HouseMapper;
import cn.bdqn.mh.pojo.Ad;
import cn.bdqn.mh.pojo.Article;
import cn.bdqn.mh.pojo.House;
import cn.bdqn.mh.service.HouseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@Slf4j
public class HouseServiceImpl implements HouseService {

    @Autowired
    private HouseMapper houseMapper;

    @Autowired
    private RedisTemplate<Object, Object> redisTemplate;//注意泛型

    @Override
    public List<House> getListGoodHouse() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<House> list= (List<House>) redisTemplate.opsForValue().get("list1");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getListGoodHouse();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("list1",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取list1集合成功!");
        }
        return list;
        //return houseMapper.getListGoodHouse();
    }

    @Override
    public List<House> getListClicks() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<House> list= (List<House>) redisTemplate.opsForValue().get("list2");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getListClicks();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("list2",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取list2集合成功!");
        }
        return list;
        //return houseMapper.getListClicks();
    }

    @Override
    public List<House> getListIsMetroLine() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<House> list= (List<House>) redisTemplate.opsForValue().get("list3");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getListIsMetroLine();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("list3",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取list3集合成功!");
        }
        return list;
        //return houseMapper.getListIsMetroLine();
    }

    @Override
    public List<House> getListByMoney() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<House> list= (List<House>) redisTemplate.opsForValue().get("list4");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getListByMoney();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("list4",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取list4集合成功!");
        }
        return list;
        //return houseMapper.getListByMoney();
    }

    @Override
    public List<House> getListByHouseType() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<House> list= (List<House>) redisTemplate.opsForValue().get("list5");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getListByHouseType();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("list5",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取list5集合成功!");
        }
        return list;
        //return houseMapper.getListByHouseType();
    }

    @Override
    public List<House> search(String title) {
//        //为了让key可读，redis的字符串序列化器
//        RedisSerializer serializer=new StringRedisSerializer();
//        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
//        //从redis数据库中读取key=books的值，并转为对象
//        List<House> list= (List<House>) redisTemplate.opsForValue().get("search");
//        if (list==null){
//            synchronized (this){//锁定，防止缓存穿透
//                log.info("redis缓存数据库中不存在，那么去mysql中加载");
//                list=houseMapper.search(title);
//                //将这个对象，写入到redis中缓存起来
//                redisTemplate.opsForValue().set("search",list);
//                log.info("写入redis，缓存list成功");
//            }
//        }else{
//            log.info("从redis缓存数据库中读取search集合成功!");
//        }
//        return list;
        return houseMapper.search(title);
    }

    @Override
    public List<House> getSaleMoney() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<House> list= (List<House>) redisTemplate.opsForValue().get("saleMoney");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getSaleMoney();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("saleMoney",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取saleMoney集合成功!");
        }
        return list;
        //return houseMapper.getSaleMoney();
    }

    @Override
    public List<Article> getVShare() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<Article> list= (List<Article>) redisTemplate.opsForValue().get("share");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getVShare();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("share",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取share集合成功!");
        }
        return list;
        //return houseMapper.getVShare();
    }

    @Override
    public List<Ad> getAd() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<Ad> list= (List<Ad>) redisTemplate.opsForValue().get("ad");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getAd();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("ad",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取ad集合成功!");
        }
        return list;
        //return houseMapper.getAd();
    }

    @Override
    public List<Article> getNewsInformation() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<Article> list= (List<Article>) redisTemplate.opsForValue().get("newsInfor");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getNewsInformation();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("newsInfor",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取newsInfor集合成功!");
        }
        return list;
        //return houseMapper.getNewsInformation();
    }

    @Override
    public List<Article> getSearchInformation() {
        //为了让key可读，redis的字符串序列化器
        RedisSerializer serializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(serializer);//设置key的序列化器
        //从redis数据库中读取key=books的值，并转为对象
        List<Article> list= (List<Article>) redisTemplate.opsForValue().get("searchInfor");
        if (list==null){
            synchronized (this){//锁定，防止缓存穿透
                log.info("redis缓存数据库中不存在，那么去mysql中加载");
                list=houseMapper.getSearchInformation();
                //将这个对象，写入到redis中缓存起来
                redisTemplate.opsForValue().set("searchInfor",list);
                log.info("写入redis，缓存list成功");
            }
        }else{
            log.info("从redis缓存数据库中读取searchInfor集合成功!");
        }
        return list;
        //return houseMapper.getSearchInformation();
    }
}
